#  from langchain.text_splitter import RecursiveCharacterTextSplitter
class RecursiveCharacterTextSplitter:
    # 构建函数 分块大小 重叠长度 分隔符列表
    def __init__(self, chunk_size=128, chunk_overlap=30, separators=None):
        self.chunk_size = chunk_size
        self.chunk_overlap = chunk_overlap
        self.separators = separators

    # 定义文本分隔的主函数
    def split_text(self, text):
        # 定义内部的递归分割函数
        def recursive_split(txt, seps):
            # 如果分隔符的列表为空，则直接按块大小切分
            if not seps:
                return [
                    txt[i : i + self.chunk_size]
                    for i in range(0, len(txt), self.chunk_size)
                ]
            # 获取第一个优先级最高的分割符
            sep = seps[0]
            # 按当前的分割符进行分割文本
            parts = txt.split(sep)
            # 定义分割结果列表
            result = []
            # 遍历每一块
            for part in parts:
                # 如果不是最后一块，则补回分割符
                if part != parts[-1]:
                    part = part + sep
                # 如果当前的段落长度大于块的大小，则需要递归用下一个分隔符进行继续分割
                if len(part) > self.chunk_size:
                    # 对这个段落用剩下的分割符进行递归分割
                    result.extend(recursive_split(part, seps[1:]))
                else:
                    result.append(part)

            # 返回分割后的结果列表
            return result

        ## 递归分隔文本，并去除空分块
        splits = [s for s in recursive_split(text, self.separators) if s.strip()]
        # 合并chunk
        # 初始化分块列表
        chunks = []
        # 初始化计数的索引
        i = 0
        # 遍历所有的分割结果
        while i < len(splits):
            chunk = splits[i]
            # 下一个分块的索引
            j = i + 1
            # 尽可能的合并多个split到一个chunk中，直到超出规定的块的大小
            while j < len(splits) and len(chunk) + len(splits[j]) <= self.chunk_size:
                chunk += splits[j]
                j += 1
            # 添加合并后的分块到结果列表中
            chunks.append(chunk)
            # 如果需要重叠，并且还有剩余的分块
            if self.chunk_overlap > 0 and j < len(splits):
                # 获取重叠的部分
                overlap = chunk[-self.chunk_overlap :]
                # 把重叠的部分添加到下一个分块的前面
                if j < len(splits):
                    splits[j] = overlap + splits[j]
            i = j
        return chunks


splitter = RecursiveCharacterTextSplitter(
    chunk_size=300,  # 每个分块最大是50个字符
    chunk_overlap=50,  # 相邻的分块重叠的字符
    separators=[
        "\n\n",  # 段落分隔符
        "\n",  # 换行符
        "。",  # 中文句号
        ".",  # 英文名号
        "，",  # 中文逗号
        ",",  # 英文逗号
    ],
)
text = """
这是第一句话。
这是第二句话，包含中文逗号，
This is the first English sentence.
This is the second English sentence.
这是第三句话.
这是第四句话，包含英文逗号,

这是第五句话，段落分隔。
这是第六句话，包含两个换行。
"""
""" chunks = splitter.split_text(text)
for i, chunk in enumerate(chunks):
    print(f"chunk:{i+1}:{chunk} {len(chunk)}") """
